﻿using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Collections;

namespace Pika.Collections.Tests
{
    [TestClass]
    public class MatrixTest
    {
        #region Champs
        Matrix _matrice, _matriceVide, _matriceUnique;
        #endregion

        #region Méthodes
        [TestInitialize]
        public void Initialize()
        {
            _matrice = new Matrix(new Size(3, 4));
            for(int i=0; i<_matrice.Size.Rows; i++)
            {
                for(int j=0; j<_matrice.Size.Columns; j++)
                {
                    _matrice[i, j] = (i * 3) + j;
                }
            }
            _matriceVide = new Matrix();

            _matriceUnique = new Matrix(1, 1);
            _matriceUnique[0, 0] = 254;
        }
        [TestMethod]
        public void MatrixCtorTest()
        {
            Assert.IsNotNull(_matriceVide);
            Assert.IsNotNull(_matriceVide.Size);

            Assert.IsNotNull(_matrice);
            Assert.IsNotNull(_matrice.Size);

            Assert.IsNotNull(_matriceUnique);
            Assert.IsNotNull(_matriceUnique.Size);
        }
        [TestMethod]
        public void MatrixCtor2Test()
        {
            Assert.IsTrue(_matriceVide.Size.Columns == 0);
            Assert.IsTrue(_matriceVide.Size.Rows == 0);

            Assert.IsTrue(_matrice.Size.Columns == 3);
            Assert.IsTrue(_matrice.Size.Rows == 4);

            Assert.IsTrue(_matriceUnique.Size.Columns == 1);
            Assert.IsTrue(_matriceUnique.Size.Rows == 1);
        }
        [TestMethod]
        public void CountTest()
        {
            Assert.IsTrue(_matriceVide.Count == 0);
            Assert.IsTrue(_matrice.Count == 12);
            Assert.IsTrue(_matriceUnique.Count == 1);
        }
        [TestMethod]
        public void GetEnumeratorTest()
        {
            int iresult;
            IEnumerator enumerateur;

            enumerateur = _matriceVide.GetEnumerator();
            Assert.IsFalse(enumerateur.MoveNext());
            Assert.IsFalse(enumerateur.MoveNext());

            iresult =0;
            enumerateur = _matrice.GetEnumerator();
            while(enumerateur.MoveNext() == true)
            {
                Assert.IsTrue(iresult == (int)enumerateur.Current);
                iresult++;
            }
            Assert.IsTrue(iresult == 12);
            Assert.IsFalse(enumerateur.MoveNext());

            enumerateur = _matriceUnique.GetEnumerator();
            Assert.IsTrue(enumerateur.MoveNext());
            Assert.IsTrue((int)enumerateur.Current == 254);
            Assert.IsFalse(enumerateur.MoveNext());

        }
        [TestMethod]
        public void SizeTest()
        {
            Assert.IsNotNull(_matriceVide.Size);
            Assert.IsTrue(_matriceVide.Size.Columns == 0);
            Assert.IsTrue(_matriceVide.Size.Rows == 0);

            Assert.IsTrue(_matrice.Size.Rows == 4);
            Assert.IsTrue(_matrice.Size.Columns == 3);

            Assert.IsTrue(_matriceUnique.Size.Columns == 1);
            Assert.IsTrue(_matriceUnique.Size.Rows == 1);
        }
        [TestMethod]
        public void TabOpTest()
        {

            Assert.IsTrue((int)_matrice[0, 0] == (int)0);
            Assert.IsTrue((int)_matrice[0, 1] == (int)1);
            Assert.IsTrue((int)_matrice[1, 0] == (int)3);
            Assert.IsTrue((int)_matrice[2, 0] == (int)6);
            Assert.IsTrue((int)_matrice[3,0] == (int)9);
            Assert.IsTrue((int)_matrice[3, 2] == (int)11);

            Assert.IsTrue((int)_matriceUnique[0, 0] == (int)254);
        }
        [TestMethod]
        public void TabOpFailTest()
        {

            try{
                _matrice[0, 3] = 5;
                Assert.Fail("Cet élément ne peut pas exister");
            }
            catch(ArgumentOutOfRangeException ex)
            {
                Assert.IsTrue(true);
            }
            try
            {
                _matriceVide[0, 0] = 1;
                Assert.Fail("C'est une matrice vide");
            }catch(ArgumentOutOfRangeException)
            {
                Assert.IsTrue(true);
            }

            try
            {
                _matrice[-1, 0] = 0;
                Assert.Fail("C'est un élément impossible");
            }catch(ArgumentOutOfRangeException)
            {
                Assert.IsTrue(true);
            }

            try
            {
                _matriceUnique[1, 0] = 0;
                Assert.Fail("C'est un élément impossible");
            }catch(ArgumentOutOfRangeException)
            {
                Assert.IsTrue(true);
            }
        }
        #endregion

        #region Propriétés
        #endregion
    }
}
